﻿using System;
using System.ComponentModel;
using System.Linq;
using System.Collections.Generic; 
using NTTDATA.BEENChina.ResultCertification.Config;
using NTTDATA.BEENChina.ResultCertification.DataStore;

namespace NTTDATA.BEENChina.ResultCertification.Checker.Name
{
   
    [Serializable]
    [VerfityAttribute(Id = "VerfityN0400", Name = "氏名检证", CategoryType = EnumCategoryType.姓名, Model = true)]
    public class VerfityN0400 : VerfityOneResult
    {

        private int _row = -1;
        private int _col = -1;
       

        [Category("要检查的行"), Description("行号")]
        public int Row { get { return _row; } set { _row = value; } }
        [Category("要检查的列"), Description("列号")]
        public int Col { get { return _col; } set { _col = value; } }



        public override bool CheckResult(List<List<string>> result, string entryCommon)
        {
            bool bresult = false;
            if (result == null)
            {
                return false;
            }

            if (entryCommon.Equals("30") || entryCommon.Equals("20"))
            {
                return false;
            }

            for (int i = 0; i < result.Count; i++)
            {
                var rowResult = result[i];

                for (int j = 0; j < rowResult.Count; j++)
                {
                    string colResult = rowResult[j];
               
                    if ( _row .Equals(-1) && _col.Equals(-1)  ||
                        _row.Equals(-1) && _col.Equals(j) ||
                        _row.Equals(i) && _col.Equals(-1) )
                    {
                        var splitEntryResult = new Split.SplitEntryResult(
                            ChildImageObject.CategorySetting.DataFormat, colResult);

                        string kanaResult = splitEntryResult.GetNameOfKana();
                        kanaResult = Util.JaStringUtil.ChangeJaInputToHirakana(kanaResult);

                        string kannjiResult = splitEntryResult.GetNameOfKannji();

                        // 把结果里面的假名部分 片假名 -> 平假名
                        bresult = CheckErrorNameResult(kanaResult, kannjiResult);

                        if (bresult) break;
                    }
                    
                }
                if (bresult) break;
            }


            if (bresult)
            {
                System.Console.WriteLine("VerfityN0400");
            }

            return bresult;
        }

       // private string[] _companys = new [] {"会社", "法人", "株", "有"};
        private string[] _honorifics = new[]{"様","君","殿","さま","サマ","くん","クン","どの","ドノ","さん","サン","ちゃん","チャン"};
       

        protected bool CheckErrorNameResult(string kanaResult, string kannjiResult)
        {
           

            bool bresult = false;

            var kanaSplit = Split.SplitNameResult.GetSplitResult(kanaResult);
            
          

            if (!String.IsNullOrEmpty(kannjiResult))
            {
                //Contains customerChar
                //包含外字
                if( ContainsCustomerChar(kannjiResult))
                {
                    return  false;
                }

                //var kannjiSplit = kannjiResult.Split(new string[] { string.Empty }, StringSplitOptions.None);
                var kannjiSplit = Split.SplitNameResult.GetSplitResult(kannjiResult);

                //分割完的结果超过5个字符
                //分割后 名字里面有 公司名等
                if (kannjiSplit.Any((t => t.Length > 5)))
                {
                    return false;
                }


                if (kannjiSplit.Count.Equals(1))
                {
                    //姓名栏不包含空格［"　"］时不进行抽出
                    //姓名超过5 的任务是公司名之类的

                    if (kannjiResult.Length < 5)
                    {
                        if (CheckErrorNameResult(kanaSplit, kannjiSplit))
                        {
                            bresult = true;
                        }
                    }


                    /* //如果不包含 「会社」or「法人」or「株）」or「有）」时
                   if (! _companys.Any( kannjiResult.Contains ))
                   {
                       if (CheckErrorNameResult(kanaSplit, kannjiSplit))
                       {
                           bresult = true;
                       }
                   }*/

                }
                else if (kannjiSplit.Count.Equals(2))
                {
                    ////2部分里 如果任何一部分有 「会社」or「法人」or「株）」or「有）」时
                    ////略过不检查
                    //if (_companys.Any(kannjiResult.Contains))
                    //{
                    //    return false;
                    //}

                    //分成2部分时：任何一部分出现检索库以外的内容即抽出；
                    if (CheckErrorNameResult(kanaSplit, kannjiSplit))
                    {
                        bresult = true;
                    }
                }
                else if (kannjiSplit.Count.CompareTo(2) > 0)
                {
                    //分成2部分以上时：检证最后2部分,
                    //              最后1部分是「様」or「君」or「殿」or「さま」or「サマ」or「くん」or「クン」or「どの」or「ドノ」or「さん」or「サン」or「ちゃん」or「チャン」时
                    //              检证倒数第2,3部分
                    //结果中包含中点时，中点前后分别确认，包含括号时，括号内需要检证，括号外进行确认。


                    int honorificIndex = -1;
                    if (kannjiSplit.Any(t =>
                    {
                        if (_honorifics.Any(t.Contains))
                        {
                            honorificIndex = kannjiSplit.IndexOf(t);
                            return true;
                        }
                        return false;
                    }))


                    //if (_honorifics.Any(t => kannjiSplit[2].Contains(t)))
                    {
                        var newkannjiSplit = new string[kannjiSplit.Count];
                        
                        kannjiSplit.CopyTo(newkannjiSplit);
                       // newkannjiSplit.ToList().RemoveAt(2);
                        newkannjiSplit.ToList().RemoveAt(honorificIndex);


                        if (CheckErrorNameResult(kanaSplit, newkannjiSplit.ToList()))
                        {
                            bresult = true;
                        }
                    }
                    else
                    {
                        if (CheckErrorNameResult(kanaSplit, kannjiSplit))
                        {
                            bresult = true;
                        }
                    }

                }
            }


       
            return bresult;
        }
        /// <summary>
        /// true error
        /// false ok
        /// </summary>
        /// <param name="kanaSplit"></param>
        /// <param name="kannjiSplit"></param>
        /// <returns></returns>
        private static bool CheckErrorNameResult(List<string> kanaSplit, List<string> kannjiSplit)
        {
            IJaNameClientAccess jaNameClientAccess = new JaNameClientAccess() ;
            
           /* //汉字部分 判断是不是在库里
            if (kannjiSplit.Select(jaNameClientAccess.FindName).Any(bfind => !bfind))
            {
                return true;
            }
            //假名部分 判断是不是在库里
            if (kanaSplit.Select(jaNameClientAccess.FindKana).Any(bfind => !bfind))
            {
                return true;
            }*/

            //判断汉字的名是不是全是 英文或假名
            //是的话 忽略
            if (kannjiSplit != null && kannjiSplit.Count.Equals(2))
            {
                var kannjiCount = kannjiSplit[0].ToArray().Sum(t =>
                {
                    if (Util.StrHelper.IsKannji(t))
                    {
                        return 1;
                    }
                    return 0;
                });

                //汉字数量为0
                if (kannjiCount.Equals(0))
                    return false;
 
            }



            //汉字的姓不在检索库里
            if (kannjiSplit != null && kannjiSplit.Count >0 && !jaNameClientAccess.FindName(kannjiSplit[0]))
                return true;

            //假名的姓不在检索库里
            if (kanaSplit != null && kanaSplit.Count >0 && !jaNameClientAccess.FindKana(kanaSplit[0]))
                return true;


            if (kannjiSplit == null)
                return false;

            //分成2部分时：任何一部分出现检索库以外的内容即抽出；
            for (int i = 0; i < kannjiSplit.Count; i++)
            {
                //［姓名］的［名］不检证了
                if (i>0)
                    continue;
                //
                string kannji = kannjiSplit[i];
                List<string> kana;

                if (kannjiSplit.Count > 1 && i.Equals(0))
                {
                    //姓名第一部分必须是汉字 否则错
                    kana = jaNameClientAccess.GetFirstNameKana(kannji);
                    if (kana != null && kana.Count>0  ) 
                    {
                        if (kanaSplit != null && kanaSplit.Count>0 )
                        {
                            bool check =
                                kanaSplit.Any(t => kana.Contains(t));

                            if (!check)
                            {
                                return true;
                            }
                        }

                    }
                    else
                    {
                        return true;
                    }
                }
                else 
                {
                    if (i.Equals(0))
                    {
                        //判断是否是姓
                        kana = jaNameClientAccess.GetFirstNameKana(kannji);
                        if (kana != null && kana.Count > 0)
                        {
                            if (kanaSplit != null && kanaSplit.Count > 0)
                            {
                                bool check = kanaSplit.Any(t => kana.Contains(t));
                                if (!check)
                                {
                                    return true;
                                }
                            }
                        }
                    }


                    /* 
                     * //［姓名］的［名］不检证了
                     * 如果需要判断 放开
                     //判断是否是名
                     kana = jaNameClientAccess.GetLastNameKana(kannji);
                     if (kana != null && kana.Count > 0)
                     {
                         if (kanaSplit != null && kanaSplit.Count > 0)
                         {
                             bool check = kanaSplit.Any(t => kana.Contains(t));
                             if (!check)
                             {
                                 return true;
                             }
                         }
                     }
                     */
                }
            }
            return false;
        }

       /* private static bool CheckErrorNameResult(List<string> kanaSplit, List<string> kannjiSplit)
        {
            IJaNameClientAccess jaNameClientAccess = new JaNameClientAccess(); 
           

            //分成2部分时：任何一部分出现检索库以外的内容即抽出；
            for (int i = 0; i < kannjiSplit.Count; i++)
            {
                string kannji = kannjiSplit[i];

                //汉字里面有假名不算错
                if (jaNameClientAccess.FindName(kannji))
                {
                    //return false;
                    //找到对应的假名 如果有
                    if (kanaSplit.Count > i)
                    {
                        string kana = kanaSplit[i];

                        //假名不在检索库
                        //假名里面有汉字算错,所以只检索kana库
                        if (!jaNameClientAccess.FindKana(kana))
                        {
                            return false;
                        }
                    }
                }
                else
                {
                    //汉字不在检索库
                    return false;
                }
            }
            return true;
        }*/
     

        

        private bool ContainsCustomerChar(string kannjiResult)
        {
            string _customerCharA = "";
            string[] _customerCharB = new[] { "・","髙","﨑","取締役","病院" ,
                                            "医師" ,"院長" ,"理事長" ,"所長" 
                                            , "（","(","）",")"
                                            ,"会社", "法人", "株","京セラ"};
            //_companys = new[] { "会社", "法人", "株", "有" };

            if (_customerCharA.ToArray().Any(kannjiResult.Contains))
            {
                return true;
            }
            if (_customerCharB.Any(kannjiResult.Contains))
            {
                return true;
            }
            return false;
        }

    }
}
